'use strict';

const Service = require('egg').Service;
const jwt = require('jsonwebtoken');
const User = require('../model/user');

class AuthService extends Service {
  /**
   * 用户注册
   * @param {object} userData - 用户数据
   */
  async register(userData) {
    const { username, email, password, role = 'user' } = userData;

    // 1. 验证参数
    if (!username || !email || !password) {
      return {
        success: false,
        message: '请填写完整信息'
      };
    }

    // 2. 检查用户名是否已存在
    const existingUser = await User.findOne({ where: { username } });
    if (existingUser) {
      return {
        success: false,
        message: '用户名已存在'
      };
    }

    // 3. 检查邮箱是否已被使用
    const existingEmail = await User.findOne({ where: { email } });
    if (existingEmail) {
      return {
        success: false,
        message: '邮箱已被注册'
      };
    }

    // 4. 创建用户
    const newUser = await User.create({
      username,
      email,
      password, // 简化实现，未加密
      role: role, // 使用传入的角色
      nickname: username, // 默认昵称为用户名
    });

    // 5. 返回结果（不返回密码）
    return {
      success: true,
      message: '注册成功',
      data: {
        id: newUser.id,
        username: newUser.username,
        email: newUser.email,
        role: newUser.role,
        nickname: newUser.nickname
      }
    };
  }

  /**
   * 用户登录
   * @param {object} loginData - 登录数据
   * @param {string} expectedRole - 期望的角色类型（可选）
   */
  async login(loginData, expectedRole = null) {
    const { username, password } = loginData;

    // 1. 验证参数
    if (!username || !password) {
      return {
        success: false,
        message: '请输入用户名和密码'
      };
    }

    // 2. 查找用户
    const user = await User.findOne({ where: { username } });
    if (!user) {
      return {
        success: false,
        message: '用户不存在'
      };
    }

    // 3. 验证密码
    if (user.password !== password) {
      return {
        success: false,
        message: '密码错误'
      };
    }

    // 4. 检查用户状态
    if (user.status === 0) {
      return {
        success: false,
        message: '账号已被禁用，请联系管理员'
      };
    }

    // 5. 角色验证（如果指定了期望角色）
    if (expectedRole && user.role !== expectedRole) {
      return {
        success: false,
        message: expectedRole === 'admin' ? '无管理员权限' : '无用户权限'
      };
    }

    // 6. 生成 JWT token
    const token = this.generateToken(user);

    // 7. 返回结果（不返回密码）
    return {
      success: true,
      message: '登录成功',
      data: {
        token,
        user: {
          id: user.id,
          username: user.username,
          email: user.email,
          role: user.role,
          nickname: user.nickname,
          avatar: user.avatar
        }
      }
    };
  }

  /**
   * 获取用户信息
   * @param {number} userId - 用户ID
   */
  async getUserInfo(userId) {
    const user = await User.findByPk(userId, {
      attributes: { exclude: ['password'] } // 不返回密码
    });

    if (!user) {
      return {
        success: false,
        message: '用户不存在'
      };
    }

    return {
      success: true,
      data: user
    };
  }

  /**
   * 获取所有用户
   */
  async getAllUsers() {
    const allUsers = await User.findAll({
      attributes: { exclude: ['password'] }, // 不返回密码
      order: [['created_at', 'DESC']]
    });

    return {
      success: true,
      data: allUsers
    };
  }

  /**
   * 生成 JWT Token
   * @param {object} user - 用户对象
   */
  generateToken(user) {
    const { config } = this;

    // JWT payload
    const payload = {
      userId: user.id,
      username: user.username,
      role: user.role
    };

    // 生成 token
    return jwt.sign(payload, config.jwt.secret, {
      expiresIn: config.jwt.expiresIn
    });
  }

  /**
   * 验证 JWT Token
   * @param {string} token - token字符串
   */
  verifyToken(token) {
    const { config } = this;

    if (!token) {
      return null;
    }

    try {
      const decoded = jwt.verify(token, config.jwt.secret);
      return decoded; // 返回解码后的payload { userId, username, role }
    } catch (error) {
      console.error('Token验证失败:', error.message);
      return null;
    }
  }

  /**
   * 更新用户资料
   * @param {number} userId - 用户ID
   * @param {object} updateData - 更新的数据
   */
  async updateProfile(userId, updateData) {
    const { nickname, email, avatar } = updateData;

    // 如果更新邮箱，检查是否已被使用
    if (email) {
      const existingEmail = await User.findOne({ where: { email } });

      if (existingEmail && existingEmail.id !== userId) {
        return {
          success: false,
          message: '该邮箱已被其他用户使用'
        };
      }
    }

    // 构建更新字段
    const updateFields = {};
    if (nickname !== undefined) updateFields.nickname = nickname;
    if (email !== undefined) updateFields.email = email;
    if (avatar !== undefined) updateFields.avatar = avatar;

    // 更新用户信息
    const [affectedRows] = await User.update(updateFields, {
      where: { id: userId }
    });

    if (affectedRows === 0) {
      return {
        success: false,
        message: '更新失败，用户不存在'
      };
    }

    // 获取更新后的用户信息
    const user = await User.findByPk(userId, {
      attributes: { exclude: ['password'] }
    });

    return {
      success: true,
      message: '资料更新成功',
      data: user
    };
  }

  /**
   * 修改密码
   * @param {number} userId - 用户ID
   * @param {object} passwordData - 密码数据
   */
  async changePassword(userId, passwordData) {
    const { oldPassword, newPassword } = passwordData;

    // 验证参数
    if (!oldPassword || !newPassword) {
      return {
        success: false,
        message: '请填写完整信息'
      };
    }

    if (newPassword.length < 6) {
      return {
        success: false,
        message: '新密码长度至少6个字符'
      };
    }

    // 查找用户
    const user = await User.findByPk(userId);

    if (!user) {
      return {
        success: false,
        message: '用户不存在'
      };
    }

    // 验证原密码
    if (user.password !== oldPassword) {
      return {
        success: false,
        message: '原密码错误'
      };
    }

    // 更新密码
    const [affectedRows] = await User.update(
      { password: newPassword },
      { where: { id: userId } }
    );

    if (affectedRows === 0) {
      return {
        success: false,
        message: '密码修改失败'
      };
    }

    return {
      success: true,
      message: '密码修改成功，请重新登录'
    };
  }
}

module.exports = AuthService;

